package com.multithreading.thread.poolExecutor;

import java.util.List;
import java.util.ArrayList;
import java.util.concurrent.*;

public class ThreadPoolTest {

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        ExecutorService executorService = new ThreadPoolExecutor(1, 5, 2, TimeUnit.SECONDS
                , new LinkedBlockingDeque<>(5));
        long startTime = System.currentTimeMillis();
        List<FutureTask> taskList = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            FutureTask task = new FutureTask(new Callable() {
                @Override
                public Object call() throws Exception {
                    Thread.sleep(1000);
                    return "A";
                }
            });
            executorService.execute(task);
            taskList.add(task);
        }
        try {
            executorService.execute(new Runnable() {
                @Override
                public void run() {
                    System.out.println("超出 阻塞队列+最大线程数 的线程");
                }
            });
        } catch (RejectedExecutionException e) {
            e.printStackTrace();
        }
        for (int i = 0; i < taskList.size(); i++) {
            FutureTask task = taskList.get(i);
            System.out.println(i + ":::" + task.get());
        }
        executorService.shutdown();
        long endTime = System.currentTimeMillis();
        System.out.println("");
        System.out.println("10个任务的执行时长为：" + (endTime - startTime) + "ms");
        /************************/
        /* 核心线程：1， 最大线程：2， 阻塞队列容量：1， 启动10个线程，报rejectedExecution */
        /* 线程先进核心线程，核心线程满了，进阻塞队列，最后是最大线程数，如果超出了报rejectedExecution */
        /* 如果队列满了，就会新启动一个线程放到最大线程数里，
            如果没有满，那么核心线程执行完任务，会继续执行阻塞队列里的任务 不会新启动一个线程 */
        /* 核心线程执行阻塞队列中的任务会用原有线程， 最大线程数里的线程是新的线程，核心线程在执行是会抛弃原有线程，使用新线程 */
        /* 核心线程：1 ， 就只有一个线程在执行任务 */
        /** 核心线程的 消费速度 赶不上 任务速度报 rejectedExecution 如何处理 */
    }
}
